Fix tests on nightly

Some output of failing tests have been tweaked, so update the associated tests.

diff --git a/tests/support/mod.rs b/tests/support/mod.rs
index 4411dd62582c32a3a8593f2631633dd6ee35f2c5..55589f35054b5ed5a284c18c75a80ff9fb92d812 100644 (file)
--- a/tests/support/mod.rs
+++ b/tests/support/mod.rs
@@ -8,6 +8,7 @@ use std::os;
 use std::path::{Path, PathBuf};
 use std::process::Output;
 use std::str;
+use std::usize;
 
 use url::Url;
 use hamcrest as ham;
@@ -137,6 +138,7 @@ impl ProjectBuilder {
         p.cwd(&self.root())
          .env("HOME", &paths::home())
          .env_remove("CARGO_HOME")  // make sure we don't pick up an outer one
+         .env_remove("CARGO_TARGET_DIR") // we assume 'target'
          .env_remove("MSYSTEM");    // assume cmd.exe everywhere on windows
         return p;
     }
@@ -316,99 +318,86 @@ impl Execs {
     }
 
     fn match_stdout(&self, actual: &Output) -> ham::MatchResult {
-        self.match_std(self.expect_stdout.as_ref(), &actual.stdout,
-                       "stdout", &actual.stderr)
-            .and(self.match_contains(self.expect_stdout_contains.as_ref(),
-                 &actual.stdout, "stdout"))
+        try!(self.match_std(self.expect_stdout.as_ref(), &actual.stdout,
+                            "stdout", &actual.stderr, false));
+        for expect in self.expect_stdout_contains.iter() {
+            try!(self.match_std(Some(expect), &actual.stdout, "stdout",
+                                &actual.stderr, true));
+        }
+        Ok(())
     }
 
     fn match_stderr(&self, actual: &Output) -> ham::MatchResult {
         self.match_std(self.expect_stderr.as_ref(), &actual.stderr,
-                       "stderr", &actual.stdout)
+                       "stderr", &actual.stdout, false)
     }
 
     #[allow(deprecated)] // connect => join in 1.3
-    fn match_contains(&self, expect: &[String], actual: &[u8],
-                      description: &str) -> ham::MatchResult {
-        for s in expect {
-            let a: Vec<&str> = match str::from_utf8(actual) {
-                Err(..) => return Err(format!("{} was not utf8 encoded",
-                                           description)),
-                Ok(actual) => actual.lines().collect(),
-            };
-            let e: Vec<&str> = s.lines().collect();
-
-            let first = e.first().unwrap();
-            let mut ai = a.iter();
-            match ai.position(|s| lines_match(first, s)) {
-                Some(_) => {
-                    let match_count = ai.zip(e.iter().skip(1))
-                                        .take_while(|&(a, e)| lines_match(a, e)).count();
-                    if match_count != (e.len() - 1) {
-                        return ham::expect(false,
-                                           format!("expected: {}\n\
-                                                    actual: {}",
-                                                    e.connect("\n"),
-                                                    a.iter().take(e.len()).map(|&s| s)
-                                                     .collect::<Vec<_>>().connect("\n")));
-                    }
-                },
-                None => {
-                    return ham::expect(false, format!("no match"));
+    fn match_std(&self, expected: Option<&String>, actual: &[u8],
+                 description: &str, extra: &[u8],
+                 partial: bool) -> ham::MatchResult {
+        let out = match expected {
+            Some(out) => out,
+            None => return ham::success(),
+        };
+        let actual = match str::from_utf8(actual) {
+            Err(..) => return Err(format!("{} was not utf8 encoded",
+                                       description)),
+            Ok(actual) => actual,
+        };
+        // Let's not deal with \r\n vs \n on windows...
+        let actual = actual.replace("\r", "");
+        let actual = actual.replace("\t", "<tab>");
+
+        let mut a = actual.lines();
+        let e = out.lines();
+
+        let diffs = if partial {
+            let mut min = self.diff_lines(a.clone(), e.clone(), partial);
+            while let Some(..) = a.next() {
+                let a = self.diff_lines(a.clone(), e.clone(), partial);
+                if a.len() < min.len() {
+                    min = a;
                 }
-            };
-        }
-        ham::expect(true, format!("OK"))
+            }
+            min
+        } else {
+            self.diff_lines(a, e, partial)
+        };
+        ham::expect(diffs.len() == 0,
+                    format!("differences:\n\
+                            {}\n\n\
+                            other output:\n\
+                            `{}`", diffs.connect("\n"),
+                            String::from_utf8_lossy(extra)))
+
     }
 
-    #[allow(deprecated)] // connect => join in 1.3
-    fn match_std(&self, expected: Option<&String>, actual: &[u8],
-                 description: &str, extra: &[u8]) -> ham::MatchResult {
-        match expected.map(|s| &s[..]) {
-            None => ham::success(),
-            Some(out) => {
-                let actual = match str::from_utf8(actual) {
-                    Err(..) => return Err(format!("{} was not utf8 encoded",
-                                               description)),
-                    Ok(actual) => actual,
-                };
-                // Let's not deal with \r\n vs \n on windows...
-                let actual = actual.replace("\r", "");
-                let actual = actual.replace("\t", "<tab>");
-
-                let a = actual.lines();
-                let e = out.lines();
-
-                let diffs = zip_all(a, e).enumerate();
-                let diffs = diffs.filter_map(|(i, (a,e))| {
-                    match (a, e) {
-                        (Some(a), Some(e)) => {
-                            if lines_match(&e, &a) {
-                                None
-                            } else {
-                                Some(format!("{:3} - |{}|\n    + |{}|\n", i, e, a))
-                            }
-                        },
-                        (Some(a), None) => {
-                            Some(format!("{:3} -\n    + |{}|\n", i, a))
-                        },
-                        (None, Some(e)) => {
-                            Some(format!("{:3} - |{}|\n    +\n", i, e))
-                        },
-                        (None, None) => panic!("Cannot get here")
+    fn diff_lines<'a>(&self, actual: str::Lines<'a>, expected: str::Lines<'a>,
+                      partial: bool) -> Vec<String> {
+        let actual = actual.take(if partial {
+            expected.clone().count()
+        } else {
+            usize::MAX
+        });
+        zip_all(actual, expected).enumerate().filter_map(|(i, (a,e))| {
+            match (a, e) {
+                (Some(a), Some(e)) => {
+                    if lines_match(&e, &a) {
+                        None
+                    } else {
+                        Some(format!("{:3} - |{}|\n    + |{}|\n", i, e, a))
                     }
-                });
-
-                let diffs = diffs.collect::<Vec<String>>().connect("\n");
-
-                ham::expect(diffs.len() == 0,
-                            format!("differences:\n\
-                                    {}\n\n\
-                                    other output:\n\
-                                    `{}`", diffs,
-                                    String::from_utf8_lossy(extra)))
+                },
+                (Some(a), None) => {
+                    Some(format!("{:3} -\n    + |{}|\n", i, a))
+                },
+                (None, Some(e)) => {
+                    Some(format!("{:3} - |{}|\n    +\n", i, e))
+                },
+                (None, None) => panic!("Cannot get here")
             }
-        }
+        }).collect()
     }
 }
 

diff --git a/tests/test_cargo_test.rs b/tests/test_cargo_test.rs
index 32787d998a728592a7e55490cc43f80b7c7dc791..587aa448d5be85d1bbd6970cc5b9d3878a70b450 100644 (file)
--- a/tests/test_cargo_test.rs
+++ b/tests/test_cargo_test.rs
@@ -189,9 +189,9 @@ test!(cargo_test_failing_test {
                 execs().with_stdout("hello\n"));
 
     assert_that(p.cargo("test"),
-                execs().with_stdout(format!("\
-{} foo v0.5.0 ({})
-{} target[..]foo-[..]
+                execs().with_stdout_contains(format!("\
+{compiling} foo v0.5.0 ({url})
+{running} target[..]foo-[..]
 
 running 1 test
 test test_hello ... FAILED
@@ -202,17 +202,14 @@ failures:
 <tab>thread 'test_hello' panicked at 'assertion failed: \
     `(left == right)` (left: \
     `\"hello\"`, right: `\"nope\"`)', src[..]foo.rs:12
-
-
-
+", compiling = COMPILING, url = p.url(), running = RUNNING))
+                    .with_stdout_contains("\
 failures:
     test_hello
 
 test result: FAILED. 0 passed; 1 failed; 0 ignored; 0 measured
-
-",
-        COMPILING, p.url(), RUNNING))
-              .with_status(101));
+")
+                    .with_status(101));
 });
 
 test!(test_with_lib_dep {
@@ -1902,7 +1899,8 @@ test!(no_fail_fast {
         }
         "#);
     assert_that(p.cargo_process("test").arg("--no-fail-fast"),
-                execs().with_status(101).with_stdout(format!("\
+                execs().with_status(101)
+                       .with_stdout_contains(format!("\
 {compiling} foo v0.0.1 ([..])
 {running} target[..]foo[..]
 
@@ -1911,12 +1909,8 @@ running 0 tests
 test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
 
 {running} target[..]test_add_one[..]
-
-running 2 tests
-[..]\n[..]\n[..]\n[..]\n[..]\n[..]\n[..]\n[..]\n[..]\n[..]
-failures:
- fail_add_one_test
-
+", compiling = COMPILING, running = RUNNING))
+                       .with_stdout_contains(format!("\
 test result: FAILED. 1 passed; 1 failed; 0 ignored; 0 measured
 
 {running} target[..]test_sub_one[..]
@@ -1933,7 +1927,7 @@ test sub_one_0 ... ok
 
 test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
 
-", compiling = COMPILING, running = RUNNING, doctest = DOCTEST)))
+", running = RUNNING, doctest = DOCTEST)))
 });
 
 test!(test_multiple_packages {